// package com.warm.core.reflect;
//
// import com.warm.core.utils.DateUtils;
// import com.warm.core.utils.text.Convert;
// import org.apache.commons.lang3.StringUtils;
// import org.apache.commons.lang3.Validate;
// import org.slf4j.Logger;
// import org.slf4j.LoggerFactory;
//
// import java.lang.reflect.*;
// import java.util.Date;
//
// /**
//  * 反射工具类. 提供调用getter/setter方法, 访问私有变量, 调用私有方法, 获取泛型类型Class, 被AOP过的真实类等工具函数.
//  * ReflectUtils
//  * @author warm
//  */
// @SuppressWarnings("rawtypes")
// public class ReflectUtils
// {
//     public static final String SETTER_PREFIX = "set";
//
//     public static final String GETTER_PREFIX = "get";
//
//     public static final String CGLIB_CLASS_SEPARATOR = "$$";
//
//     private static Logger logger = LoggerFactory.getLogger(ReflectUtils.class);
//
//     /**
//      * 直接读取对象属性值, 无视private/protected修饰符, 不经过getter函数.
//      */
//     @SuppressWarnings("unchecked")
//     public static <E> E getFieldValue(final Object obj, final String fieldName)
//     {
//         Field field = getAccessibleField(obj, fieldName);
//         if (field == null)
//         {
//             logger.debug("在 [" + obj.getClass() + "] 中，没有找到 [" + fieldName + "] 字段 ");
//             return null;
//         }
//         E result = null;
//         try
//         {
//             result = (E) field.get(obj);
//         }
//         catch (IllegalAccessException e)
//         {
//             logger.error("不可能抛出的异常{}", e.getMessage());
//         }
//         return result;
//     }
//
//     /**
//      * 直接设置对象属性值, 无视private/protected修饰符, 不经过setter函数.
//      */
//     public static <E> void setFieldValue(final Object obj, final String fieldName, final E value)
//     {
//         Field field = getAccessibleField(obj, fieldName);
//         if (field == null)
//         {
//             // throw new IllegalArgumentException("在 [" + obj.getClass() + "] 中，没有找到 [" + fieldName + "] 字段 ");
//             logger.debug("在 [" + obj.getClass() + "] 中，没有找到 [" + fieldName + "] 字段 ");
//             return;
//         }
//         try
//         {
//             field.set(obj, value);
//         }
//         catch (IllegalAccessException e)
//         {
//             logger.error("不可能抛出的异常: {}", e.getMessage());
//         }
//     }
//
//     /**
//      * 循环向上转型, 获取对象的DeclaredField, 并强制设置为可访问.
//      * 如向上转型到Object仍无法找到, 返回null.
//      */
//     public static Field getAccessibleField(final Object obj, final String fieldName)
//     {
//         // 为空不报错。直接返回 null
//         if (obj == null)
//         {
//             return null;
//         }
//         Validate.notBlank(fieldName, "fieldName can't be blank");
//         for (Class<?> superClass = obj.getClass(); superClass != Object.class; superClass = superClass.getSuperclass())
//         {
//             try
//             {
//                 Field field = superClass.getDeclaredField(fieldName);
//                 makeAccessible(field);
//                 return field;
//             }
//             catch (NoSuchFieldException e)
//             {
//                 continue;
//             }
//         }
//         return null;
//     }
//
//     /**
//      * 改变private/protected的成员变量为public，尽量不调用实际改动的语句，避免JDK的SecurityManager抱怨。
//      */
//     public static void makeAccessible(Field field)
//     {
//         if ((!Modifier.isPublic(field.getModifiers()) || !Modifier.isPublic(field.getDeclaringClass().getModifiers())
//                 || Modifier.isFinal(field.getModifiers())) && !field.isAccessible())
//         {
//             field.setAccessible(true);
//         }
//     }
//
//     /**
//      * 通过反射, 获得Class定义中声明的泛型参数的类型, 注意泛型必须定义在父类处
//      * 如无法找到, 返回Object.class.
//      */
//     @SuppressWarnings("unchecked")
//     public static <T> Class<T> getClassGenricType(final Class clazz)
//     {
//         return getClassGenricType(clazz, 0);
//     }
//
//     /**
//      * 通过反射, 获得Class定义中声明的父类的泛型参数的类型.
//      * 如无法找到, 返回Object.class.
//      */
//     public static Class getClassGenricType(final Class clazz, final int index)
//     {
//         Type genType = clazz.getGenericSuperclass();
//
//         if (!(genType instanceof ParameterizedType))
//         {
//             logger.debug(clazz.getSimpleName() + "'s superclass not ParameterizedType");
//             return Object.class;
//         }
//
//         Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
//
//         if (index >= params.length || index < 0)
//         {
//             logger.debug("Index: " + index + ", Size of " + clazz.getSimpleName() + "'s Parameterized Type: "
//                     + params.length);
//             return Object.class;
//         }
//         if (!(params[index] instanceof Class))
//         {
//             logger.debug(clazz.getSimpleName() + " not set the actual class on superclass generic parameter");
//             return Object.class;
//         }
//
//         return (Class) params[index];
//     }
//
//     public static Class<?> getUserClass(Object instance)
//     {
//         if (instance == null)
//         {
//             throw new RuntimeException("Instance must not be null");
//         }
//         Class clazz = instance.getClass();
//         if (clazz != null && clazz.getName().contains(CGLIB_CLASS_SEPARATOR))
//         {
//             Class<?> superClass = clazz.getSuperclass();
//             if (superClass != null && !Object.class.equals(superClass))
//             {
//                 return superClass;
//             }
//         }
//         return clazz;
//
//     }
//
//     /**
//      * 获取 目标对象
//      * @param proxy 代理对象
//      * @return 目标对象
//      * @throws Exception
//      */
//     public static Object getTarget(Object proxy) {
//         try {
//             if (!AopUtils.isAopProxy(proxy)) {
//                 return proxy;
//             }
//             //判断是jdk还是cglib代理
//             if (AopUtils.isJdkDynamicProxy(proxy)) {
//                 proxy = getJdkDynamicProxyTargetObject(proxy);
//             } else {
//                 proxy = getCglibProxyTargetObject(proxy);
//             }
//         } catch (Exception e) {
//             throw new RuntimeException("获取 目标对象");
//         }
//         return getTarget(proxy);
//     }
//
//     private static Object getCglibProxyTargetObject(Object proxy) throws Exception {
//         Field h = proxy.getClass().getDeclaredField("CGLIB$CALLBACK_0");
//         h.setAccessible(true);
//         Object dynamicAdvisedInterceptor = h.get(proxy);
//         Field advised = dynamicAdvisedInterceptor.getClass().getDeclaredField("advised");
//         advised.setAccessible(true);
//         Object target = ((AdvisedSupport) advised.get(dynamicAdvisedInterceptor)).getTargetSource().getTarget();
//         return target;
//     }
//
//     private static Object getJdkDynamicProxyTargetObject(Object proxy) throws Exception {
//         Field h = proxy.getClass().getSuperclass().getDeclaredField("h");
//         h.setAccessible(true);
//         AopProxy aopProxy = (AopProxy) h.get(proxy);
//         Field advised = aopProxy.getClass().getDeclaredField("advised");
//         advised.setAccessible(true);
//         Object target = ((AdvisedSupport) advised.get(aopProxy)).getTargetSource().getTarget();
//         return target;
//     }
// }
